home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / pcr / pcr4_4.lha / DIST / debugnub / CirioNubProcs1.c < prev    next >
C/C++ Source or Header  |  1992-04-16  |  16KB  |  621 lines
  1. /* begincopyright
  2.   Copyright (c) 1988-1992 Xerox Corporation. All rights reserved.
  3.   Use and copying of this software and preparation of derivative works based
  4.   upon this software are permitted. Any distribution of this software or
  5.   derivative works must comply with all applicable United States export
  6.   control laws. This software is made available AS IS, and Xerox Corporation
  7.   makes no warranty about the software, its performance or its conformity to
  8.   any specification. Any person obtaining a copy of this software is requested
  9.   to send their name and post office or electronic mail address to:
  10.     PCR Coordinator
  11.     Xerox PARC
  12.     3333 Coyote Hill Rd.
  13.     Palo Alto, CA 94304
  14.   endcopyright */
  15.  
  16. /*
  17.  * CirioNubProcs1.c
  18.  *
  19.  * Demers, February 25, 1992 11:46:00 am PST
  20.  */
  21.  
  22. #include "xr/Errno.h"
  23. #include "xr/Threads.h"
  24. #include "xr/ThreadsBackdoor.h"
  25. #include "xr/IncrementalLoad.h"
  26.  
  27. #include "xr/CirioNubProtocol.h"
  28. #include "xr/CirioNubMarshall.h"
  29. #include "xr/CirioNubProcs.h"
  30. #include "xr/CirioNubInnerProcs.h"
  31. #include "xr/CirioNubEnvironment.h"
  32.  
  33.  
  34. CirioNubRetCode
  35. CirioNubServeWaitSig(argc, args)
  36.     int argc;
  37.     unsigned *args;
  38. {
  39.     bool gotSig;
  40.     CirioNubRetCode ans;
  41.  
  42.     if( argc != 1 )
  43.     return(cnrc_badArgs);
  44.     if( (!cns.cns_gotSig) && (args[0] != 0) )
  45.     (void)CirioNubSlaveSleep((unsigned)(args[0]));
  46.     if( (gotSig = cns.cns_gotSig) != FALSE )
  47.     cns.cns_gotSig = FALSE;
  48.     if( (ans = CirioNubPutInt32(gotSig)) != cnrc_ok )
  49.     return ans;
  50.     if( (ans = CirioNubPutInt32(XR_sysArea->sa_dbStat)) != cnrc_ok )
  51.     return ans;
  52.     return cnrc_ok;
  53. }
  54.  
  55.  
  56.  
  57. CirioNubRetCode
  58. CirioNubServeSetDBStat (argc, args)
  59.     int argc;
  60.     unsigned *args;
  61. {
  62.     XR_DBStat stat;
  63.     unsigned timeoutMsec;
  64.     unsigned sleepMsec = 100;
  65.     unsigned timeoutSoFar;
  66.     int i, j;
  67.  
  68.     if( argc != 2 )
  69.     return(cnrc_badArgs);
  70.     stat = (XR_DBStat)(args[0]);
  71.     timeoutMsec = (unsigned)(args[1]);
  72.  
  73.     i = 0;
  74.     timeoutSoFar = 0;
  75.     for(;;) {
  76.     XR_sysArea->sa_dbStat = stat;
  77.     if( (i % 5) == 0 ) CirioNubKickDebuggee();
  78.     i += 1;
  79.         for( j = 0; j < XR_sysArea->sa_numVP; j++ ) {
  80.         if( XR_sysArea->sa_vpe[j].vpe_dbStat != stat ) goto Nope;
  81.     }
  82.     return CirioNubPutInt32(0);
  83.       Nope:
  84.     if( timeoutSoFar >= timeoutMsec ) return CirioNubPutInt32(-1);
  85.     (void)CirioNubSlaveSleep(sleepMsec);
  86.     timeoutSoFar += sleepMsec;
  87.     }
  88. }
  89.  
  90.  
  91. CirioNubRetCode
  92. CirioNubServeGetMaxThreads(argc, args)
  93.     int argc;
  94.     unsigned *args;
  95. {
  96.     CirioNubRetCode ans;
  97.  
  98.     if( argc != 0 ) return(cnrc_badArgs);
  99.  
  100.     if( (ans = CirioNubPutCard32(XR_maxThreads)) != cnrc_ok )
  101.         return ans;
  102.     return cnrc_ok;
  103. }
  104.  
  105.  
  106. CirioNubRetCode
  107. CirioNubServeGetThreads(argc, args)
  108.     int argc;
  109.     unsigned *args;
  110. {
  111. #   define MAX_THREAD_DATA 128
  112.     int i, iLow, iHigh, localAns;
  113.     CirioNubThreadData dp, dpLim;
  114.     XR_Thread t;
  115.     CirioNubRetCode ans;
  116.     struct CirioNubThreadDataRep data[MAX_THREAD_DATA];
  117.  
  118.     if( argc != 2 ) return(cnrc_badArgs);
  119.     iLow = (int)(args[0]);
  120.     iHigh = (int)(args[1]);
  121.     if( iLow >= 0 ) {
  122.         if( iHigh >= XR_maxThreads ) iHigh = XR_maxThreads - 1;
  123.         if( iLow > iHigh ) return(cnrc_badArgs);
  124.     } else {
  125.         iHigh = iLow; /* both < 0, that's okay ... */
  126.     }
  127.     dp = &(data[0]);
  128.     dpLim = &(data[MAX_THREAD_DATA]);
  129.     for( i = iLow; i <= iHigh; i++ ) {
  130.         if( dp >= dpLim ) return cnrc_space;
  131.         localAns = CirioNubInnerGetThread(i, dp);
  132.         if( localAns == 0 ) dp++;
  133.     }
  134.     ans = CirioNubPutBlock32(
  135.     &(data[0]),
  136.     ((unsigned)(dp)) - ((unsigned)(&(data[0])))
  137.     );
  138.     if( ans != cnrc_ok ) return ans;
  139.     return cnrc_ok;
  140. #undef MAX_THREAD_DATA
  141. }
  142.  
  143.  
  144. CirioNubRetCode
  145. CirioNubServeGetThreadFromCTRep(argc, args)
  146.     int argc;
  147.     unsigned *args;
  148. {
  149.     CirioNubRetCode ans;
  150.     XR_Thread t;
  151.     unsigned gen;
  152.     unsigned innerArgs[2];
  153.     
  154.     if( argc != 2 ) return(cnrc_badArgs);
  155.     t = (XR_Thread)(args[0]);
  156.     gen = (unsigned)(args[1]);
  157.     if( (t < XR_sysArea->sa_threadPool) || 
  158.             (t >= &(XR_sysArea->sa_threadPool[XR_maxThreads])) )
  159.         return(cnrc_badArgs);
  160.     if( gen != t->t_gen )
  161.         return(cnrc_badArgs);
  162.     innerArgs[0] = innerArgs[1] = (unsigned)(-((int)(t->t_index)));
  163.     return CirioNubServeGetThreads(2, innerArgs);
  164. }
  165.  
  166.  
  167. CirioNubRetCode
  168. CirioNubServePCtoInfo(argc, args)
  169.     int argc;
  170.     unsigned *args;
  171. {
  172.     CirioNubRetCode ans;
  173.     int innerAns;
  174.     XR_Pointer argValue;
  175.     struct CirioNubPCInfoRep buf;
  176.     
  177.     if( argc != 1 ) return(cnrc_badArgs);
  178.     argValue = (XR_Pointer)(args[0]);
  179.  
  180.     innerAns = CirioNubInnerPCtoInfo(argValue, &buf);
  181.     if( innerAns != 0 ) return cnrc_badArgs;
  182.  
  183.   Out:
  184.  
  185.     {
  186.         if( (ans = CirioNubPutString(buf.procName)) != cnrc_ok )
  187.             return ans;
  188.         if( (ans = CirioNubPutCard32(buf.procSymID)) != cnrc_ok )
  189.             return ans;
  190.         if( (ans = CirioNubPutString(buf.fileName)) != cnrc_ok )
  191.             return ans;
  192.         if( (ans = CirioNubPutCard32(buf.fileSeqNum)) != cnrc_ok )
  193.             return ans;
  194.         if( (ans = CirioNubPutString(buf.guessedEmbeddedFileName)) != cnrc_ok )
  195.             return ans;
  196.         if( (ans = CirioNubPutCard32(buf.guessedEmbeddedFileSymID)) != cnrc_ok )
  197.             return ans;
  198.     }
  199.     return cnrc_ok;
  200. }
  201.  
  202.  
  203. static bool
  204. CirioNubServeKillWorldInner()
  205. {
  206.     (void) CirioNubSlaveSleep(2000);
  207.     XR_KillWorld();
  208.     _exit(0);
  209.     /*NOTREACHED*/
  210.     return TRUE;
  211. }
  212.  
  213.  
  214. CirioNubRetCode
  215. CirioNubServeKillWorld(argc, args)
  216.     int argc;
  217.     unsigned *args;
  218. {
  219.     CirioNubRetCode ans;
  220.  
  221.     if( argc != 0 ) return(cnrc_badArgs);
  222.     XR_iope->iope_workerProc = CirioNubServeKillWorldInner;
  223.     return cnrc_ok;
  224. }
  225.  
  226.  
  227. CirioNubRetCode
  228. CirioNubServeIssueThreadCommand(argc, args)
  229.     int argc;
  230.     unsigned *args;
  231. {
  232.     XR_Thread t;
  233.     int index;
  234.     bool setFreeze;
  235.     bool freeze;
  236.     bool setMsg;
  237.     XR_DBMsg msg;
  238.  
  239.     if( argc != 5 ) return(cnrc_badArgs);
  240.     index = (int)(args[0]);
  241.     setFreeze = (bool)(args[1]);
  242.     freeze = (bool)(args[2]);
  243.     setMsg = (bool)(args[3]);
  244.     msg = (XR_DBMsg)(args[4]);
  245.     if( (index < XR_sysArea->sa_numVP)
  246.             || (index >= XR_maxThreads) )
  247.         return CirioNubPutInt32(-1);
  248.     t = &(XR_sysArea->sa_threadPool[index]);
  249.     if( setFreeze ) t->t_dbFreeze = freeze;
  250.     if( setMsg ) t->t_dbMsg = msg;
  251.     return CirioNubPutInt32(0);
  252. }
  253.  
  254.  
  255. CirioNubRetCode
  256. CirioNubServeGetDBStat(argc, args)
  257.     int argc;
  258.     unsigned *args;
  259. {
  260.     XR_Thread examinee;
  261.     CirioNubRetCode ans;
  262.     int oldStat;
  263.     int oldExamineeIndex;
  264.     unsigned timeoutMsec;
  265.     int newStat;
  266.     int newExamineeIndex;
  267.     unsigned sleepTime;
  268.  
  269.     if( argc != 3 ) return( cnrc_badArgs );
  270.     oldStat = (int)(args[0]);
  271.     oldExamineeIndex = (int)(args[1]);
  272.     timeoutMsec = (unsigned)(args[2]);
  273.     for(;;) {
  274.         newStat = XR_sysArea->sa_dbStat;
  275.         examinee = XR_sysArea->sa_examinee;
  276.         newExamineeIndex = ( (examinee != NIL) ? examinee->t_index : (-1) );
  277.         if( timeoutMsec == 0 )
  278.             break;
  279.         if( (newStat != oldStat) || (newExamineeIndex != oldExamineeIndex) )
  280.             break;
  281.         sleepTime = ( (timeoutMsec < 250) ? timeoutMsec : 250 );
  282.         (void)CirioNubSlaveSleep(sleepTime);
  283.         timeoutMsec -= sleepTime;
  284.     }
  285.     if( (ans = CirioNubPutInt32(newStat)) != cnrc_ok )
  286.         return ans;
  287.     if( (ans = CirioNubPutInt32(newExamineeIndex)) != cnrc_ok )
  288.         return ans;
  289.     return cnrc_ok;
  290. }
  291.  
  292.  
  293. CirioNubRetCode
  294. CirioNubServeGetFileEntry(argc, args)
  295.     int argc;
  296.     unsigned *args;
  297. {
  298.     unsigned desiredSeqNum;
  299.     CirioNubRetCode ans;
  300.     int innerAns;
  301.     struct CirioNubFileEntryRep buf;
  302.  
  303.     if( argc != 1 ) return(cnrc_badArgs);
  304.     desiredSeqNum = (unsigned)(args[0]);
  305.  
  306.     innerAns = CirioNubInnerGetFileEntry(desiredSeqNum, &buf);
  307.     if( innerAns != 0 ) return cnrc_badArgs;
  308.  
  309.     {
  310.         if( (ans = CirioNubPutCard32(buf.seqNum)) != cnrc_ok )
  311.         return ans;
  312.         if( (ans = CirioNubPutCard32(buf.commitPoint)) != cnrc_ok )
  313.         return ans;
  314.     if( (ans = CirioNubPutString(buf.fileName)) != cnrc_ok )
  315.         return ans;
  316.         if( (ans = CirioNubPutCard32(buf.fOffset)) != cnrc_ok )
  317.         return ans;
  318.         if( (ans = CirioNubPutCard32(buf.fMagic)) != cnrc_ok )
  319.         return ans;
  320.     if( (ans = CirioNubPutCard32(buf.size)) != cnrc_ok )
  321.         return ans;
  322.     if( (ans = CirioNubPutCard32(buf.mTime)) != cnrc_ok )
  323.         return ans;
  324.     if( (ans = CirioNubPutCard32(buf.sMagic)) != cnrc_ok )
  325.         return ans;
  326.         if( (ans = CirioNubPutCard32(((unsigned)(buf.stamp))))
  327.                 != cnrc_ok )
  328.             return ans;
  329.         if( (ans = CirioNubPutCard32(buf.stampSize)) != cnrc_ok )
  330.             return ans;
  331.         if( (ans = CirioNubPutCard32(((unsigned)(buf.readerData)))) != cnrc_ok )
  332.         return ans;
  333.     if( (ans = CirioNubPutCard32(buf.readerDataSize)) != cnrc_ok )
  334.         return ans;
  335.     if( (ans = CirioNubPutCard32(buf.patchReloc)) != cnrc_ok )
  336.         return ans;
  337.     if( (ans = CirioNubPutCard32(buf.patchSize)) != cnrc_ok )
  338.         return ans;
  339.     if( (ans = CirioNubPutCard32(buf.textReloc)) != cnrc_ok )
  340.         return ans;
  341.     if( (ans = CirioNubPutCard32(buf.textSize)) != cnrc_ok )
  342.         return ans;
  343.     if( (ans = CirioNubPutCard32(buf.dataReloc)) != cnrc_ok )
  344.         return ans;
  345.     if( (ans = CirioNubPutCard32(buf.dataSize)) != cnrc_ok )
  346.         return ans;
  347.     if( (ans = CirioNubPutCard32(buf.bssReloc)) != cnrc_ok )
  348.         return ans;
  349.     if( (ans = CirioNubPutCard32(buf.bssSize)) != cnrc_ok )
  350.         return ans;
  351.     if( (ans = CirioNubPutCard32(buf.commonReloc)) != cnrc_ok )
  352.         return ans;
  353.     if( (ans = CirioNubPutCard32(buf.commonSize)) != cnrc_ok )
  354.         return ans;
  355.     }
  356.     return cnrc_ok;
  357. }
  358.  
  359.  
  360. static CirioNubRetCode
  361. CirioNubPutSymEntryResult(errCode, buf)
  362.     int errCode;
  363.     CirioNubSymEntry buf;
  364. {
  365.     CirioNubRetCode ans;
  366.  
  367.     if( (buf == NIL) && (errCode == 0) )
  368.         errCode = (-1);
  369.  
  370.     if( (ans = CirioNubPutInt32(errCode)) != cnrc_ok )
  371.         return ans;
  372.     if( errCode != 0 )
  373.         return cnrc_ok;
  374.     if( (ans = CirioNubPutCard32(buf->symID)) != cnrc_ok )
  375.         return ans;
  376.     if( (ans = CirioNubPutString(buf->name)) != cnrc_ok )
  377.         return ans;
  378.     if( (ans = CirioNubPutCard32(buf->type)) != cnrc_ok )
  379.         return ans;
  380.     if( (ans = CirioNubPutCard32(buf->value)) != cnrc_ok )
  381.         return ans;
  382.     if( (ans = CirioNubPutCard32(buf->size)) != cnrc_ok )
  383.         return ans;
  384.     if( (ans = CirioNubPutCard32(buf->fileSeqNum)) != cnrc_ok )
  385.         return ans;
  386.     return cnrc_ok;
  387. }
  388.  
  389.  
  390. CirioNubRetCode
  391. CirioNubServeGetMatchingSymEntryByName(argc, args)
  392.     int argc;
  393.     unsigned *args;
  394. {
  395.     CirioNubRetCode ans;
  396.     unsigned symID;
  397.     char *pattern;
  398.     bool caseSensitive;
  399.     unsigned wantedTypes;
  400.     unsigned ignoredClasses;
  401.     int numToSkip;
  402.     int innerAns;
  403.     struct CirioNubSymEntryRep buf;
  404.  
  405.     if( argc != 6 ) return( cnrc_badArgs );
  406.     symID = (unsigned)(args[0]);
  407.     pattern = (char *)(args[1]);
  408.     caseSensitive = (bool)(args[2]);
  409.     wantedTypes = (unsigned)(args[3]);
  410.     ignoredClasses = (unsigned)(args[4]);
  411.     numToSkip = (int)(args[5]);
  412.  
  413.     innerAns = CirioNubInnerGetMatchingSymEntryByName (
  414.             symID, pattern, caseSensitive, wantedTypes,
  415.             ignoredClasses, numToSkip, &buf
  416.     );
  417.     ans = CirioNubPutSymEntryResult( ((innerAns == 0) ? 0 : (-1)), &buf );
  418.     if( ans != cnrc_ok )
  419.         return ans;
  420.  
  421.     return cnrc_ok;
  422. }
  423.  
  424.  
  425. CirioNubRetCode
  426. CirioNubServeGetMatchingSymEntryByValue(argc, args)
  427.     int argc;
  428.     unsigned *args;
  429. {
  430.     CirioNubRetCode ans;
  431.     unsigned symID;
  432.     unsigned val;
  433.     unsigned wantedTypes;
  434.     unsigned ignoredClasses;
  435.     int numToSkip;
  436.     int innerAns;
  437.     struct CirioNubSymEntryRep buf;
  438.  
  439.     if( argc != 5 ) return( cnrc_badArgs );
  440.     symID = (unsigned)(args[0]);
  441.     val = (unsigned)(args[1]);
  442.     wantedTypes = (unsigned)(args[2]);
  443.     ignoredClasses = (unsigned)(args[3]);
  444.     numToSkip = (int)(args[4]);
  445.  
  446.     innerAns = CirioNubInnerGetMatchingSymEntryByValue (
  447.             symID, val, wantedTypes, ignoredClasses, numToSkip, &buf
  448.     );
  449.     ans = CirioNubPutSymEntryResult( ((innerAns == 0) ? 0 : (-1)), &buf );
  450.     if( ans != cnrc_ok )
  451.         return ans;
  452.  
  453.     return cnrc_ok;
  454. }
  455.  
  456.  
  457.  
  458.  
  459. /* OBSOLETE: */
  460.  
  461. CirioNubRetCode
  462. CirioNubServeLookupSymEntryByName(argc, args)
  463.     int argc;
  464.     unsigned *args;
  465. {
  466.     CirioNubRetCode ans;
  467.     char *sym;
  468.     bool caseSensitive;
  469.     bool externOnly;
  470.     int numToSkip;
  471.     int innerAns;
  472.     struct CirioNubSymEntryRep buf;
  473.  
  474.     if( argc != 4 ) return( cnrc_badArgs );
  475.     sym = (char *)(args[0]);
  476.     caseSensitive = (bool)(args[1]);
  477.     externOnly = (bool)(args[2]);
  478.     numToSkip = (int)(args[3]);
  479.  
  480.     innerAns = CirioNubInnerGetMatchingSymEntryByName (
  481.             0, sym, caseSensitive, WANT_ALL_TYPES,
  482.             (externOnly ? IGNORE_INTERNAL : IGNORE_NONE),
  483.             numToSkip, &buf
  484.     );
  485.     ans = CirioNubPutSymEntryResult( ((innerAns == 0) ? 0 : (-1)), &buf );
  486.     if( ans != cnrc_ok )
  487.         return ans;
  488.  
  489.     return cnrc_ok;
  490. }
  491.  
  492.  
  493.  
  494. CirioNubRetCode
  495. CirioNubServeSkipSymEntryByName(argc, args)
  496.     int argc;
  497.     unsigned *args;
  498. {
  499.     CirioNubRetCode ans;
  500.     unsigned symID;
  501.     bool caseSensitive;
  502.     bool externOnly;
  503.     int numToSkip;
  504.     int innerAns;
  505.     struct CirioNubSymEntryRep buf;
  506.  
  507.     if( argc != 4 ) return( cnrc_badArgs );
  508.     symID = (unsigned)(args[0]);
  509.     caseSensitive = (bool)(args[1]);
  510.     externOnly = (bool)(args[2]);
  511.     numToSkip = (int)(args[3]);
  512.  
  513.     innerAns = CirioNubInnerGetMatchingSymEntryByName(
  514.             symID, NIL, caseSensitive, WANT_ALL_TYPES,
  515.             (externOnly ? IGNORE_INTERNAL : IGNORE_NONE),
  516.             numToSkip, &buf
  517.     );
  518.     ans = CirioNubPutSymEntryResult( ((innerAns == 0) ? 0 : (-1)), &buf );
  519.     if( ans != cnrc_ok )
  520.         return ans;
  521.  
  522.     return cnrc_ok;
  523. }
  524.  
  525.  
  526.  
  527. CirioNubRetCode
  528. CirioNubServeLookupSymEntryByValue(argc, args)
  529.     int argc;
  530.     unsigned *args;
  531. {
  532.     CirioNubRetCode ans;
  533.     unsigned val;
  534.     int numToSkip;
  535.     int innerAns;
  536.     struct CirioNubSymEntryRep buf;
  537.  
  538.     if( argc != 2 ) return( cnrc_badArgs );
  539.     val = (unsigned)(args[0]);
  540.     numToSkip = (int)(args[1]);
  541.  
  542.     innerAns = CirioNubInnerGetMatchingSymEntryByValue (
  543.             NIL, val, WANT_ALL_TYPES, IGNORE_NONE, numToSkip, &buf
  544.     );
  545.     ans = CirioNubPutSymEntryResult( ((innerAns == 0) ? 0 : (-1)), &buf );
  546.     if( ans != cnrc_ok )
  547.         return ans;
  548.  
  549.     return cnrc_ok;
  550. }
  551.  
  552.  
  553.  
  554. CirioNubRetCode
  555. CirioNubServeSkipSymEntryByValue(argc, args)
  556.     int argc;
  557.     unsigned *args;
  558. {
  559.     CirioNubRetCode ans;
  560.     unsigned symID;
  561.     int numToSkip;
  562.     int innerAns;
  563.     struct CirioNubSymEntryRep buf;
  564.  
  565.     if( argc != 2 ) return( cnrc_badArgs );
  566.     symID = (unsigned)(args[0]);
  567.     numToSkip = (int)(args[1]);
  568.  
  569.     innerAns = CirioNubInnerGetMatchingSymEntryByValue(
  570.             symID, 0, WANT_ALL_TYPES, IGNORE_NONE, numToSkip, &buf
  571.     );
  572.     ans = CirioNubPutSymEntryResult( ((innerAns == 0) ? 0 : (-1)), &buf );
  573.     if( ans != cnrc_ok )
  574.         return ans;
  575.  
  576.     return cnrc_ok;
  577. }
  578.  
  579.  
  580.  
  581. CirioNubRetCode
  582. CirioNubServeLookupSymEntryByID(argc, args)
  583.     int argc;
  584.     unsigned *args;
  585. {
  586.     CirioNubRetCode ans;
  587.     unsigned symID;
  588.     int innerAns;
  589.     struct CirioNubSymEntryRep buf;
  590.  
  591.     if( argc != 1 ) return( cnrc_badArgs );
  592.     symID = (unsigned)(args[0]);
  593.  
  594.     innerAns = CirioNubInnerGetMatchingSymEntryByValue(
  595.             symID, 0, WANT_ALL_TYPES, IGNORE_NONE, 0, &buf
  596.     );
  597.     ans = CirioNubPutSymEntryResult( ((innerAns == 0) ? 0 : (-1)), &buf );
  598.     if( ans != cnrc_ok )
  599.         return ans;
  600.  
  601.     return cnrc_ok;
  602. }
  603.  
  604.  
  605. CirioNubRetCode
  606. CirioNubServeGetInstrSetAndOpSys(argc, args)
  607.     int argc;
  608.     unsigned *args;
  609. {
  610.     CirioNubRetCode ans;
  611.     struct CirioNubInstrSetAndOpSysRep buf;
  612.     int innerAns;
  613.  
  614.     if( argc != 0 ) return cnrc_badArgs;
  615.     innerAns = CirioNubInnerGetInstrSetAndOpSys(&buf);
  616.     if( innerAns != 0 ) return cnrc_badArgs;
  617.     if( (ans = CirioNubPutString(buf.instrSet)) != cnrc_ok ) return ans;
  618.     if( (ans = CirioNubPutString(buf.opSys)) != cnrc_ok ) return ans;
  619.     return cnrc_ok;
  620. }
  621.